/**
 * AI分析配置管理器
 * 负责管理5种分析任务类型的配置参数
 */
class ConfigManager {
    constructor() {
        this.currentConfigType = 'RegionalAnalysis';
        this.configData = {};
        this.defaultConfigs = {
            RegionalAnalysis: {
                analysis_levels: ['地市', '区县'],
                region_codes: '',
                enable_coordinate_analysis: false,
                prompt: '请分析以下信访数据的地域分布特征，重点关注投诉热点区域和趋势变化。'
            },
            ComplaintTypeAnalysis: {
                prompt: '请对信访内容进行类型分类分析，识别主要的投诉类型和占比情况。'
            },
            SentimentAnalysis: {
                prompt: '请分析信访内容的情感倾向，包括正面、负面、中性情绪的分布和原因。'
            },
            ComplianceAnalysis: {
                prompt: '请评估信访答复的规范性，检查是否符合相关政策法规和标准格式要求。'
            },
            DuplicateAnalysis: {
                filter_words: ['重复', '再次', '又'],
                prompt: '请识别重复或相似的信访内容，分析重复投诉的原因和模式。'
            }
        };
        
        this.init();
    }

    /**
     * 初始化配置管理器
     */
    async init() {
        console.log('初始化AI分析配置管理器...');
        
        // 绑定事件监听器
        this.bindEvents();
        
        // 加载配置数据
        await this.loadAllConfigs();
        
        // 初始化当前标签页
        this.switchTab(this.currentConfigType);
    }

    /**
     * 绑定事件监听器
     */
    bindEvents() {
        // 标签切换事件已通过HTML onclick绑定

        // 表单实时验证
        document.addEventListener('input', (e) => {
            if (e.target.form && e.target.form.id.includes('Form')) {
                this.validateForm(e.target.form);
            }
        });

        // 复选框变化事件
        document.addEventListener('change', (e) => {
            if (e.target.type === 'checkbox' && e.target.name === 'analysis_levels') {
                this.updateAnalysisLevelsDisplay();
            }

            // 经纬度分析开关变化事件
            if (e.target.type === 'checkbox' && e.target.name === 'enable_coordinate_analysis') {
                this.updateCoordinateAnalysisSwitch(e.target);
            }
        });
    }

    /**
     * 更新经纬度分析开关状态
     * @param {HTMLInputElement} checkbox - 开关复选框元素
     */
    updateCoordinateAnalysisSwitch(checkbox) {
        console.log('更新经纬度分析开关状态:', checkbox.checked);

        // 手动管理Tailwind CSS样式类
        const switchDiv = checkbox.closest('label').querySelector('div');
        if (switchDiv) {
            if (checkbox.checked) {
                switchDiv.classList.remove('bg-gray-200');
                switchDiv.classList.add('bg-indigo-600');
            } else {
                switchDiv.classList.remove('bg-indigo-600');
                switchDiv.classList.add('bg-gray-200');
            }
        }
    }

    /**
     * 切换配置标签
     * @param {string} configType - 配置类型
     */
    async switchTab(configType) {
        console.log('切换到配置标签:', configType);
        
        // 更新当前配置类型
        this.currentConfigType = configType;
        
        // 更新标签样式
        document.querySelectorAll('.config-tab').forEach(tab => {
            if (tab.dataset.configType === configType) {
                tab.classList.add('active', 'text-indigo-600', 'border-b-2', 'border-indigo-600');
                tab.classList.remove('text-slate-600');
            } else {
                tab.classList.remove('active', 'text-indigo-600', 'border-b-2', 'border-indigo-600');
                tab.classList.add('text-slate-600');
            }
        });

        // 显示对应的配置内容
        document.querySelectorAll('.config-content').forEach(content => {
            content.classList.add('hidden');
        });
        
        const targetContent = document.getElementById(configType + 'Config');
        if (targetContent) {
            targetContent.classList.remove('hidden');
        }

        // 加载该类型的配置数据
        await this.loadConfig(configType);
    }

    /**
     * 加载指定类型的配置
     * @param {string} configType - 配置类型
     */
    async loadConfig(configType) {
        try {
            const response = await fetch(`/api/ai-analysis-config/${configType}`, {
                method: 'GET',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${this.getAuthToken()}`
                }
            });

            if (response.ok) {
                const data = await response.json();
                this.configData[configType] = data.config_data;
                this.populateForm(configType, data.config_data);
                this.updateConfigStatus(configType, true);
            } else {
                console.warn('配置加载失败，使用默认配置');
                this.loadDefaultConfig(configType);
            }
        } catch (error) {
            console.error('加载配置失败:', error);
            this.loadDefaultConfig(configType);
            NotificationService.warning('配置加载失败，已使用默认配置');
        }
    }

    /**
     * 加载默认配置
     * @param {string} configType - 配置类型
     */
    loadDefaultConfig(configType) {
        const defaultConfig = this.defaultConfigs[configType] || {};
        this.configData[configType] = defaultConfig;
        this.populateForm(configType, defaultConfig);
        this.updateConfigStatus(configType, false);
    }

    /**
     * 填充表单数据
     * @param {string} configType - 配置类型
     * @param {object} configData - 配置数据
     */
    populateForm(configType, configData) {
        // 修复表单ID映射问题，使用camelCase格式
        const formIdVariations = [
            configType.charAt(0).toLowerCase() + configType.slice(1) + 'Form', // camelCase: regionalAnalysisForm
            configType.toLowerCase() + '_form', // simple lowercase: regionalanalysis_form
            configType.toLowerCase().replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase() + '_form' // snake_case: regional_analysis_form
        ];

        let form = null;
        for (const formId of formIdVariations) {
            form = document.getElementById(formId);
            if (form) {
                console.log(`找到表单: ${formId} for configType: ${configType}`);
                break;
            }
        }

        if (!form) {
            console.error(`找不到表单元素，尝试的ID: ${formIdVariations.join(', ')}`);
            return;
        }

        console.log(`开始填充表单数据 for ${configType}:`, configData);

        // 填充表单字段
        console.log('开始填充表单数据，完整配置数据:', configData);
        Object.keys(configData).forEach(key => {
            const element = form.querySelector(`[name="${key}"]`);
            if (element) {
                console.log(`填充字段 ${key}:`, configData[key], '元素类型:', element.type);
                if (element.type === 'checkbox') {
                    // 处理复选框（多选）
                    if (Array.isArray(configData[key])) {
                        const checkboxes = form.querySelectorAll(`[name="${key}"]`);
                        checkboxes.forEach(checkbox => {
                            checkbox.checked = configData[key].includes(checkbox.value);
                        });
                    } else if (key === 'enable_coordinate_analysis') {
                        // 特殊处理经纬度分析开关
                        const boolValue = Boolean(configData[key]);
                        console.log(`设置经纬度分析开关为: ${boolValue} (原始值: ${configData[key]}, 类型: ${typeof configData[key]})`);
                        console.log(`复选框元素:`, element);

                        // 设置checked属性
                        element.checked = boolValue;

                        // 手动管理Tailwind CSS样式类以解决peer状态问题
                        const switchDiv = element.closest('label').querySelector('div');
                        if (switchDiv) {
                            if (boolValue) {
                                switchDiv.classList.remove('bg-gray-200');
                                switchDiv.classList.add('bg-indigo-600');
                            } else {
                                switchDiv.classList.remove('bg-indigo-600');
                                switchDiv.classList.add('bg-gray-200');
                            }
                        }

                        console.log(`设置后复选框checked状态:`, element.checked);
                    } else {
                        // 处理其他单选复选框
                        const boolValue = Boolean(configData[key]);
                        element.checked = boolValue;
                        console.log(`设置其他复选框 ${key} 为: ${boolValue}`);
                    }
                } else if (element.tagName === 'TEXTAREA' || element.tagName === 'INPUT') {
                    // 处理文本输入
                    if (Array.isArray(configData[key])) {
                        element.value = configData[key].join('\n');
                    } else {
                        element.value = configData[key] || '';
                    }
                }
            } else {
                console.warn(`未找到字段元素: ${key}`);
            }
        });

        // 更新分析级别显示
        if (configType === 'RegionalAnalysis') {
            this.updateAnalysisLevelsDisplay();
        }
    }

    /**
     * 更新分析级别显示
     */
    updateAnalysisLevelsDisplay() {
        const checkboxes = document.querySelectorAll('input[name="analysis_levels"]:checked');
        const container = checkboxes[0]?.closest('.grid');
        if (container) {
            container.querySelectorAll('label').forEach(label => {
                const checkbox = label.querySelector('input[type="checkbox"]');
                if (checkbox && checkbox.checked) {
                    label.classList.add('border-indigo-500', 'bg-indigo-50');
                    label.classList.remove('border-slate-200');
                } else {
                    label.classList.remove('border-indigo-500', 'bg-indigo-50');
                    label.classList.add('border-slate-200');
                }
            });
        }
    }

    /**
     * 保存配置
     * @param {string} configType - 配置类型
     */
    async saveConfig(configType, event) {
        try {
            // 确保阻止默认的表单提交行为
            if (event) {
                event.preventDefault();
                event.stopPropagation();
            }

            console.log(`开始保存配置: ${configType}`);
            const formData = this.getFormData(configType);
            console.log(`获取到的表单数据:`, formData);
            console.log(`经纬度分析开关值:`, formData.enable_coordinate_analysis, '类型:', typeof formData.enable_coordinate_analysis);

            // 前端基本验证
            if (configType === 'RegionalAnalysis') {
                if (!formData.analysis_levels || formData.analysis_levels.length === 0) {
                    if (typeof NotificationService !== 'undefined') {
                        NotificationService.error('请至少选择一个区域分析级别');
                    } else {
                        NotificationService.error('请至少选择一个区域分析级别');
                    }
                    return;
                }
                if (!formData.prompt || formData.prompt.trim() === '') {
                    if (typeof NotificationService !== 'undefined') {
                        NotificationService.error('请输入区域分析提示词');
                    } else {
                        NotificationService.error('请输入区域分析提示词');
                    }
                    return;
                }
            } else if (['ComplaintTypeAnalysis', 'SentimentAnalysis', 'ComplianceAnalysis'].includes(configType)) {
                if (!formData.prompt || formData.prompt.trim() === '') {
                    if (typeof NotificationService !== 'undefined') {
                        NotificationService.error('请输入分析提示词');
                    } else {
                        NotificationService.error('请输入分析提示词');
                    }
                    return;
                }
            } else if (configType === 'DuplicateAnalysis') {
                if (!formData.filter_words || formData.filter_words.length === 0) {
                    if (typeof NotificationService !== 'undefined') {
                        NotificationService.error('请至少输入一个过滤词条');
                    } else {
                        NotificationService.error('请至少输入一个过滤词条');
                    }
                    return;
                }
                if (!formData.prompt || formData.prompt.trim() === '') {
                    if (typeof NotificationService !== 'undefined') {
                        NotificationService.error('请输入重复分析提示词');
                    } else {
                        NotificationService.error('请输入重复分析提示词');
                    }
                    return;
                }
            }

            // 验证配置数据
            console.log('验证配置数据...');
            const validateResponse = await fetch('/api/ai-analysis-config/validate', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${this.getAuthToken()}`
                },
                body: JSON.stringify({
                    config_type: configType,
                    config_data: formData
                })
            });

            console.log('配置验证响应:', validateResponse);

            if (validateResponse.ok) {
                const validationResult = await validateResponse.json();
                if (!validationResult.valid) {
                    throw new Error(validationResult.message || '配置验证失败');
                }
            } else {
                console.warn('验证服务暂时不可用，继续保存...');
            }

            // 发送保存请求
            const url = `/api/ai-analysis-config/${configType}`;
            console.log(`发送保存请求到: ${url}`);

            // 确保URL正确
            if (!url.startsWith('/api/ai-analysis-config/')) {
                console.error(`URL格式错误: ${url}`);
                throw new Error('请求URL格式错误');
            }

            // 确保配置类型字符串正确，不要访问.value属性
            const configTypeToSend = configType;
            console.log(`配置类型: ${configTypeToSend}, URL参数: ${configType}`);

            const response = await fetch(url, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${this.getAuthToken()}`
                },
                body: JSON.stringify({
                    config_type: configTypeToSend,
                    config_data: formData
                })
            });

            console.log(`响应状态: ${response.status} ${response.statusText}`);

            if (response.ok) {
                const data = await response.json();
                console.log('保存成功响应:', data);
                this.configData[configType] = formData;
                this.updateConfigStatus(configType, true);
                if (typeof NotificationService !== 'undefined') {
                    NotificationService.success('配置保存成功');
                } else {
                    NotificationService.success('配置保存成功');
                }
            } else {
                const error = await response.json();
                console.error('保存失败响应:', error);
                throw new Error(error.detail || error.message || '保存失败');
            }
        } catch (error) {
            console.error('保存配置失败:', error);
            if (typeof NotificationService !== 'undefined') {
                NotificationService.error('配置保存失败: ' + error.message);
            } else {
                NotificationService.error('配置保存失败: ' + error.message);
            }
        }
    }

    /**
     * 获取表单数据
     * @param {string} configType - 配置类型
     * @returns {object} 表单数据
     */
    getFormData(configType) {
        // 修复表单ID映射问题，优先使用camelCase格式
        const formIdVariations = [
            configType.charAt(0).toLowerCase() + configType.slice(1) + 'Form', // camelCase: regionalAnalysisForm
            configType.toLowerCase() + '_form', // simple lowercase: regionalanalysis_form
            configType.toLowerCase().replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase() + '_form' // snake_case: regional_analysis_form
        ];

        let form = null;
        for (const formId of formIdVariations) {
            form = document.getElementById(formId);
            if (form) {
                console.log(`getFormData 找到表单: ${formId} for configType: ${configType}`);
                break;
            }
        }

        if (!form) {
            console.error(`getFormData 找不到表单元素，尝试的ID: ${formIdVariations.join(', ')}`);
            return {};
        }

        const formData = {};
        const formDataObj = new FormData(form);

        // 特殊处理经纬度分析开关（确保在FormData处理之前）
        const coordinateAnalysisCheckbox = form.querySelector('input[name="enable_coordinate_analysis"]');
        if (coordinateAnalysisCheckbox) {
            formData.enable_coordinate_analysis = Boolean(coordinateAnalysisCheckbox.checked);
        }

        // 处理普通字段
        for (let [key, value] of formDataObj.entries()) {
            // 跳过已特殊处理的字段
            if (key === 'enable_coordinate_analysis') {
                continue;
            }
            if (formData[key]) {
                if (Array.isArray(formData[key])) {
                    formData[key].push(value);
                } else {
                    formData[key] = [formData[key], value];
                }
            } else {
                formData[key] = value;
            }
        }

        // 特殊处理复选框
        const checkboxes = form.querySelectorAll('input[type="checkbox"][name="analysis_levels"]:checked');
        if (checkboxes.length > 0) {
            formData.analysis_levels = Array.from(checkboxes).map(cb => cb.value);
        }

        // 特殊处理过滤词条（文本区域转换为数组）
        if (formData.filter_words && typeof formData.filter_words === 'string') {
            formData.filter_words = formData.filter_words.split('\n')
                .map(word => word.trim())
                .filter(word => word.length > 0);
        }

        // 调试信息
        console.log(`配置类型 ${configType} 获取的表单数据:`, formData);

        // 基本验证
        if (configType === 'RegionalAnalysis') {
            if (!formData.analysis_levels || formData.analysis_levels.length === 0) {
                console.warn('区域分析级别未选择');
            }
            if (!formData.prompt || formData.prompt.trim() === '') {
                console.warn('区域分析提示词为空');
            }
        }

        return formData;
    }

    /**
     * 验证配置数据
     * @param {string} configType - 配置类型
     * @param {object} configData - 配置数据
     * @returns {object} 验证结果
     */
    async validateConfig(configType, configData) {
        try {
            const response = await fetch('/api/ai-analysis-config/validate', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${this.getAuthToken()}`
                },
                body: JSON.stringify({
                    config_type: configType,
                    config_data: configData
                })
            });

            const result = await response.json();
            return result;
        } catch (error) {
            console.error('配置验证失败:', error);
            return { valid: false, message: '配置验证失败: ' + error.message };
        }
    }

    /**
     * 验证表单
     * @param {HTMLFormElement} form - 表单元素
     */
    validateForm(form) {
        let isValid = true;
        
        // 检查必填字段
        const requiredFields = form.querySelectorAll('[required]');
        requiredFields.forEach(field => {
            if (!field.value.trim()) {
                field.classList.add('border-red-500');
                isValid = false;
            } else {
                field.classList.remove('border-red-500');
            }
        });

        // 特殊验证
        if (form.id === 'regionalAnalysisForm') {
            const checkedLevels = form.querySelectorAll('input[name="analysis_levels"]:checked');
            if (checkedLevels.length === 0) {
                if (typeof NotificationService !== 'undefined') {
                  NotificationService.warning('请至少选择一个区域分析级别');
              } else {
                  NotificationService.warning('请至少选择一个区域分析级别');
              }
                isValid = false;
            }
        }

        return isValid;
    }

    /**
     * 重置配置
     * @param {string} configType - 配置类型
     */
    resetConfig(configType) {
        if (confirm('确定要重置此配置吗？所有未保存的更改将丢失。')) {
            this.loadDefaultConfig(configType);
            if (typeof NotificationService !== 'undefined') {
                NotificationService.info('配置已重置为默认值');
            } else {
                NotificationService.info('配置已重置为默认值');
            }
        }
    }

    /**
     * 加载配置模板
     * @param {string} configType - 配置类型
     */
    async loadTemplate(configType) {
        try {
            const response = await fetch(`/api/ai-analysis-config/templates/${configType}`, {
                method: 'GET',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${this.getAuthToken()}`
                }
            });

            if (response.ok) {
                const templates = await response.json();
                if (templates.length > 0) {
                    const template = templates[0]; // 使用第一个模板
                    this.populateForm(configType, template.template_data);
                    if (typeof NotificationService !== 'undefined') {
                      NotificationService.success('模板加载成功');
                  } else {
                      NotificationService.success('模板加载成功');
                  }
                } else {
                    if (typeof NotificationService !== 'undefined') {
                        NotificationService.warning('没有可用的模板');
                    } else {
                        NotificationService.warning('没有可用的模板');
                    }
                }
            }
        } catch (error) {
            console.error('加载模板失败:', error);
            if (typeof NotificationService !== 'undefined') {
                NotificationService.error('模板加载失败');
            } else {
                NotificationService.error('模板加载失败');
            }
        }
    }

    /**
     * 刷新所有配置
     */
    async refreshConfigs() {
        console.log('刷新所有配置...');
        await this.loadAllConfigs();
        if (typeof NotificationService !== 'undefined') {
            NotificationService.success('配置已刷新');
        } else {
            NotificationService.success('配置已刷新');
        }
    }

    /**
     * 加载所有配置
     */
    async loadAllConfigs() {
        try {
            const response = await fetch('/api/ai-analysis-config/list', {
                method: 'GET',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${this.getAuthToken()}`
                }
            });

            if (response.ok) {
                const configs = await response.json();
                
                // 如果当前配置类型有数据，重新加载
                if (this.currentConfigType) {
                    await this.loadConfig(this.currentConfigType);
                }
            }
        } catch (error) {
            console.error('加载配置列表失败:', error);
        }
    }

    /**
     * 更新配置状态
     * @param {string} configType - 配置类型
     * @param {boolean} isConfigured - 是否已配置
     */
    updateConfigStatus(configType, isConfigured) {
        // 更新标签页状态指示
        const tab = document.querySelector(`[data-config-type="${configType}"]`);
        if (tab) {
            if (isConfigured) {
                tab.classList.add('font-semibold');
                // 可以添加已配置的视觉指示器
            } else {
                tab.classList.remove('font-semibold');
            }
        }
    }

    /**
     * 获取认证令牌
     * @returns {string} 认证令牌
     */
    getAuthToken() {
        // 从localStorage获取认证令牌
        return localStorage.getItem('auth_token') || '';
    }
}

// 全局配置管理器实例
let configManager;

// 页面加载完成后初始化
document.addEventListener('DOMContentLoaded', () => {
    configManager = new ConfigManager();
});

// 导出配置管理器供全局使用
window.configManager = configManager;